
import { Base64Utils } from '../utils/base64Utils.js';

const base64Utils = new Base64Utils();

// Gitee工具类
export class GiteeUtils {
    static API_BASE_URL = 'https://gitee.com/api/v5';
    // 获取用户名
    async getUser(token) {
            // 检查是否已缓存用户名
            if (GiteeUtils.repoMap && GiteeUtils.repoMap[token]) {
                console.log('使用缓存的用户名');
                return GiteeUtils.repoMap[token];
            }
            if (!token) {
                console.error('错误: 访问令牌不能为空');
                return;
            }

            try {
                console.log('正在获取仓库列表...');
                const response = await fetch(`${GiteeUtils.API_BASE_URL}/user/repos?access_token=${token}&per_page=10`, {
                    method: 'GET'
                });

                const repos = await response.json();
                if (response.ok) {
                    if (repos.length === 0) {
                        console.log('没有找到仓库');
                        return;
                    }

                    console.log(`找到 ${repos.length} 个仓库:\n`);
                    let repoUrl = ``;
                    await repos.forEach(r => {
                            repoUrl = `${r.owner.login}`;
                            return; 
                    });
                    // 存起来 
                    // 将仓库信息存储到repoMap中
                    // @param {string} token - 仓库的访问令牌
                    // @param {string} repoUrl - 仓库的owner
                    // @returns {void} 无返回值
                    GiteeUtils.repoMap = GiteeUtils.repoMap || {};
                    GiteeUtils.repoMap[token] = repoUrl;
                    return repoUrl;
                    
                } else {
                    console.error(`获取失败: ${repos.message || '未知错误'}`);
                }
            } catch (error) {
                console.error(`请求异常: ${error.message}`);
            }
            console.log('没有找到仓库'); 
            return '';
        }

    // 获取仓库地址
    async getRepos(token,repoName) {
            if (!token) {
                console.error('错误: 访问令牌不能为空');
                return;
            }

            try {
                console.log('正在获取仓库列表...');
                const response = await fetch(`${GiteeUtils.API_BASE_URL}/user/repos?access_token=${token}&per_page=10`, {
                    method: 'GET'
                });

                const repos = await response.json();
                if (response.ok) {
                    if (repos.length === 0) {
                        console.log('没有找到仓库');
                        return;
                    }

                    console.log(`找到 ${repos.length} 个仓库:\n`);
                    let repoUrl = ``;
                    repos.forEach(r => {
                        console.log(`  仓库:${r.name}, 配置值`+ repoName + ',' + (repoName == `${r.name}`));
                        if(repoName == `${r.name}`) {
                            repoUrl = `${r.html_url}`;
                            return;
                        }
                    });
                    return repoUrl;
                    
                } else {
                    console.error(`获取失败: ${repos.message || '未知错误'}`);
                }
            } catch (error) {
                console.error(`请求异常: ${error.message}`);
            }
            console.log('没有找到仓库'); 
            return '';
        }

        //  创建仓库
        async createRepo(token, repoName) { 
            const repoDesc = "存储书签数据";

            if (!token || !repoName) {
                console.error('错误: 访问令牌和仓库名称不能为空');
                return '错误: 访问令牌和仓库名称不能为空';
            }

            try {
                console.debug('正在创建仓库:' + repoName + '...');
                const response = await fetch(`${GiteeUtils.API_BASE_URL}/user/repos`, {
                    method: 'POST',
                    headers: {
                        'Content-Type': 'application/json',
                        'Authorization': `token ` + token
                    },
                    body: JSON.stringify({
                        name: repoName,
                        description: repoDesc,
                        private: true
                    })
                });

                const data = await response.json();
                if (response.ok) {
                    console.debug(`仓库创建成功!\n地址: ${data.html_url}\nID: ${data.id}`);
                    return "success"
                } else {
                    console.error(`创建失败: ${data.message || '未知错误'}`);
                    return (`创建失败: ${data.message || '未知错误'}`);
                }
            } catch (error) {
                console.error(`请求异常: ${error.message}`);
                return (`请求异常: ${error.message}`);
            }
        }


        // 获取文件内容
        async fetchFileContent(token,owner, repoName, filePath) {
            // 获取表单值
            const accessToken = token; 
            const repo = repoName;
            const branch = 'master';
             
            try {
                // 验证必填字段
                if (!accessToken || !owner || !repo || !filePath) {
                    console.error('请填写所有必填字段');
                    return null;
                }
                
                // 调用 Gitee API
                const apiUrl = `${GiteeUtils.API_BASE_URL}/repos/${owner}/${repo}/contents/${filePath}?access_token=${accessToken}&ref=${branch}` 
                const response = await fetch(apiUrl);
                const data = await response.json();
                
                // 处理 API 错误
                if (!response.ok) {
                    console.error(`API 请求失败，状态码: ${response.status} ,${data.message} `);
                    return null;
                }
                
                // 验证返回数据
                if (!data.content) {
                    console.error('API 返回数据不包含文件内容');
                    return null;
                }
                console.debug('文件内容:' + data.content); 
                
                // // Base64解码前先替换URL安全字符
                // const decodedContent = atob(
                //     data.content
                //         .replace(/-/g, '+')  // 替换URL安全的'-'为标准'+'
                //         .replace(/_/g, '/')  // 替换URL安全'_'为标准'/'
                // );
                const decodedContent = base64Utils.base64DecodeUnicode(data.content);
                // 显示成功消息
                console.debug('文件内容获取成功！');
                return decodedContent;
            } catch (error) {
                // 显示错误消息
                console.error(`错误: ${error.message}`);
            }
            return null;
        }
    async getFileSha(owner, repo, path, token) {
            try {
                const branch = 'master';
                const apiUrl = `${GiteeUtils.API_BASE_URL}/repos/${owner}/${repo}/contents/${path}?access_token=${token}&ref=${branch}` 

                const response = await fetch(apiUrl);
                if (!response.ok) {
                    if (response.status === 404) return null; // 文件不存在
                    const error = await response.json();
                    console.debug(`[${response.status}] ${error.message || '获取文件信息失败'}`);
                    return null;
                }
                const data = await response.json();
                return data.sha;
            } catch (error) {
                // 显示错误消息
                console.error(`错误: ${error.message}`);
            }
            return null;
        }

        // 创建文件
        async createFile(accessToken, owner, repo, filePath, content = '{}') {
            const branch = 'master'; 
            const message = '创建文件';

            // 验证必填字段
            if (!accessToken || !owner || !repo || !filePath || !content) {
                console.error('请填写所有必填字段');
                return false;
            }

           
            try {
                // 构建API请求
                const apiUrl = `${GiteeUtils.API_BASE_URL}/repos/${owner}/${repo}/contents/${filePath}` 
                // 文件内容需要Base64编码
                const base64Content = btoa(unescape(encodeURIComponent(content)));

                const response = await fetch(apiUrl, {
                    method: 'POST',
                    headers: {
                        'Content-Type': 'application/json',
                        'Authorization': `token ${accessToken}`
                    },
                    body: JSON.stringify({
                        access_token: accessToken,
                        branch: branch,
                        content: base64Content,
                        message: message
                    }),
                    timeout: 10000
                });

                const responseData = await response.json();
                if (response.ok) {
                    console.debug(`文件创建成功！文件URL: <a href="${responseData.html_url}" target="_blank">${responseData.html_url}</a>`);
                    return true;
                } else {
                    const errorMessage = responseData.message || `创建失败: HTTP状态码 ${response.status}`;
                    console.error(errorMessage, 'error');
                    return false;
                }
            } catch (error) {
                console.error('创建文件时出错:', error);
                return false;
            }
            return false;
        }

        stringToBase64(str) {
            try {
                return btoa(unescape(encodeURIComponent(str)));
            } catch (error) {
                throw new Error(`内容编码失败: ${error.message}`);
            }
        }

        async updateFile(token, owner, repo, filePath, sha, content, message) {
            // 验证
            if (!token || !owner || !repo || !filePath || !content) {
                console.error('请填写所有必填字段');
                return false;
            }
            try { 
                // 内容编码
                const base64Content = this.stringToBase64(content);
                console.debug('内容编码完成，正在获取文件信息...');

                // SHA值
                
                if(!sha) {
                    console.error('获取文件SHA值失败');
                    return false;
                }
                            
                const apiUrl = `${GiteeUtils.API_BASE_URL}/repos/${owner}/${repo}/contents/${filePath}` 

                // 构建请求
                const response = await fetch( apiUrl,
                    {
                        method: 'PUT',
                        headers: { 'Content-Type': 'application/json' },
                        body: JSON.stringify({
                            access_token: token,
                            message: message,
                            content: base64Content,
                            ...(sha && { sha: sha })
                        })
                    }
                );

                const result = await response.json();
                if (!response.ok) {
                    console.error(`[${response.status}] ${result.message || '更新失败'}`);
                    return false;
                }

                // 成功处理
                console.debug(`✅ 更新成功`);
                return true;
            } catch (error) {
                console.error('详细错误:', error);
            }

            return false;
        }
 

    // 判断仓库是否存在  0： 不存在， 1： 存在，  其他：未知
    async existRepos(token,repoName) {
            if (!token) {
                console.error('错误: 访问令牌不能为空');
                return 2;
            }

            try {
                console.log('正在获取仓库列表...');
                const response = await fetch(`${GiteeUtils.API_BASE_URL}/user/repos?access_token=${token}&per_page=10`, {
                    method: 'GET'
                });

                const repos = await response.json();
                if (response.ok) {
                    if (repos.length === 0) {
                        console.log('没有找到仓库');
                        return 0;
                    }

                    console.log(`找到 ${repos.length} 个仓库:\n`);
                    let result = 0;
                    repos.forEach(r => {
                        console.log(`  仓库:${r.name}, 配置值`+ repoName + ',' + (repoName == `${r.name}`));
                        if(repoName == `${r.name}`) {
                            result = 1;
                            return;
                        }
                    });
                    return result;
                } else {
                    console.error(`获取失败: ${repos.message || '未知错误'}`);
                    return 3;
                }
            } catch (error) {
                console.error(`请求异常: ${error.message}`);
                return 4;
            }
            console.log('没有找到仓库'); 
            return 5;
        }

        // 判断文件是否存在  0： 不存在， 1： 存在，  其他：未知
        async existFile(owner, repo, path, token) {
            try {
                const branch = 'master';
                const apiUrl = `${GiteeUtils.API_BASE_URL}/repos/${owner}/${repo}/contents/${path}?access_token=${token}&ref=${branch}` 

                const response = await fetch(apiUrl);
                if (!response.ok) {
                    const error = await response.json();
                    console.debug(`[${response.status}] ${error.message || '获取文件信息失败'}`);
                    return 4;
                }
                const data = await response.json();
                const sha = data.sha;
                if(sha === undefined || sha === null || sha.trim() === "") {
                    return 0;
                }
                return 1;
            } catch (error) {
                // 显示错误消息
                console.error(`错误: ${error.message}`);
                return 2;
            }
            return 3;
        }

    // 获取历史文件列表
    async getHisList(owner, repo, token, start = 0, end = 30) {
        const path = "";
        let files = await this.fetchFileList(owner, repo, path, token);
        let hisFiles = files.filter(file => file.name.startsWith("his_"));
        hisFiles.sort((a, b) => b.name.localeCompare(a.name));
        hisFiles = hisFiles.slice(start, end);
        return hisFiles;

    }

    // 获取历史文件列表
    async getLastHisList(owner, repo, token, last = 99) {
        const path = "";
        let files = await this.fetchFileList(owner, repo, path, token);
        let hisFiles = files.filter(file => file.name.startsWith("his_"));
        hisFiles.sort((a, b) => b.name.localeCompare(a.name));
        hisFiles = hisFiles.slice(last);
        return hisFiles;

    }

     // 获取文件列表
     async fetchFileList(owner,repo ,path ,token) { 
            try {
                const branch = 'master';
                const url = `${GiteeUtils.API_BASE_URL}/repos/${owner}/${repo}/contents/${path}?access_token=${token}&ref=${branch}` 
                const response = await fetch(url);
                if (!response.ok) {
                    throw new Error(`API 请求失败: ${response.status} ${response.statusText}`);
                }

                const files = await response.json();
                if (Array.isArray(files)) {
                    return files;
                } else {
                    console.log('API 返回格式异常');
                }
            } catch (error) {
                 console.log('错误: ${error.message}');

            }
            return [];
        }

    async delFile(token, owner, repo, filePath, sha) {
        // 验证
        if (!token || !owner || !repo || !filePath) {
            console.error('请填写所有必填字段');
            return false;
        }
        try {

            // SHA值
            if (!sha) {
                console.error('获取文件SHA值失败');
                return false;
            }

            const apiUrl = `${GiteeUtils.API_BASE_URL}/repos/${owner}/${repo}/contents/${filePath}`

            // 构建请求
            const response = await fetch(apiUrl,
                {
                    method: 'DELETE',
                    headers: { 'Content-Type': 'application/json' },
                    body: JSON.stringify({
                        access_token: token,
                        message: 'Delete his file',
                        ...(sha && { sha: sha })
                    })
                }
            );

            const result = await response.json();
            if (!response.ok) {
                console.debug(`[${response.status}] ${result.message || '删除失败'}`);
                return false;
            }

            // 成功处理
            console.debug(`删除成功`);
            return true;
        } catch (error) {
            console.error('详细错误:', error);
        }

        return false;
    }
}